Katalog wygenerowany przez ANTLR

user
-o Generated ale folder mam generated-lex-parser

ChatGPT
Rozumiem — mówisz o kompilacji np. z ANTLR i flagach typu -o Generated, a katalog faktycznie utworzył Ci się jako generated-lex-parser, tak?

To zależy od tego jak uruchamiasz generator:
Flaga -o <folder> w ANTLR4 ustawia katalog wyjściowy dla wygenerowanych plików.
  Jeśli podasz -o Generated, powinien powstać katalog Generated.
Jeżeli masz generated-lex-parser, to znaczy, że:
Albo podałeś w komendzie -o generated-lex-parser zamiast Generated,
Albo projekt (np. build script, antlr plugin, Makefile, msbuild, gradle/maven itp.) ustawia to samodzielnie,
Albo sam generator (np. dla kilku gramatyk albo przy integracji z parserem) konkatenuje nazwę.

👉 Sprawdź swoją dokładną komendę/konfigurację. Jeśli chcesz mieć folder Generated, to uruchom np.:

antlr4 -Dlanguage=CSharp -o Generated RaceLangLexer.g4 RaceLangParser.g4



a potem pliki wylądują w Generated/.

Chcesz, żebym przejrzał Ci plik z komendą (np. Makefile albo skrypt builda), żeby znaleźć gdzie wymusza nazwę generated-lex-parser?

user
-Visitor ?

ChatGPT
Masz na myśli -visitor w kontekście ANTLR? Tak, już rozjaśniam:
Flaga -visitor mówi generatorowi, żeby wygenerował klasę Visitor dla Twojej gramatyki.
Visitor to wzorzec projektowy (ang. Visitor pattern), który pozwala przechodzić po drzewie AST w kontrolowany sposób, zamiast używać Listenerów.
Przykład w C#:


var visitor = new MyLangVisitorImpl();
var result = visitor.Visit(parseTree);


W połączeniu z flagą -o Generated pliki wygenerowane w folderze Generated będą zawierać:
Lexer i Parser,
Pliki .cs z klasami Visitor (YourLangBaseVisitor.cs i YourLangVisitor.cs).

Więc jeśli chcesz mieć gotową klasę do odwiedzania AST zamiast implementować własny Listener, dodajesz po prostu -visitor do komendy ANTLR:


antlr4 -Dlanguage=CSharp -o Generated -visitor RaceLang.g4



Bez -visitor wygenerowany będzie tylko Listener, a nie Visitor.

Mogę Ci też wytłumaczyć różnicę między Listener a Visitor w praktyce dla C# – przyda się do RaceLang. Chcesz?

user
fragment vec: 'vec2' | 'vec3' | 'vec4';

ChatGPT
Wygląda na to, że definiujesz fragment gramatyki dla typów wektorowych w ANTLR. W Twoim przykładzie:


fragment vec: 'vec2' | 'vec3' | 'vec4';



Kilka uwag:
fragment w ANTLR
fragment oznacza, że nie tworzy samodzielnego tokena, a jest używany tylko jako część innych reguł.
Sam fragment nie będzie tokenem w lexerze, czyli nie możesz go bezpośrednio użyć w parserze jako vec.
Jeśli chcesz użyć vec2 | vec3 | vec4 w parserze (np. jako typ w deklaracji zmiennej), lepiej zrobić TOKEN albo regułę parsera:

   Opcja Lexer (token):
   

   VEC2: 'vec2';
   VEC3: 'vec3';
   VEC4: 'vec4';
   

   A w parserze:
   

   type: VEC2 | VEC3 | VEC4;
   


   Opcja Parser (reguła parsera):
   

   type: 'vec2' | 'vec3' | 'vec4';
   

Kiedy używać fragment:
   Fragment jest przydatny np. do dzielenia tokenów na części, np. liczby:

   

   fragment DIGIT: [0-9];
   INT: DIGIT+;
   


Podsumowując: Twój zapis fragment vec: ... nie stworzy tokenu vec, więc parser nie będzie mógł go użyć w type. Jeśli chcesz mieć typy vec2/3/4 w parserze, lepiej użyć prostego parser rule lub osobnych tokenów.

Mogę Ci napisać gotowy przykład fragmentu gramatyki RaceLang z typami wektorowymi, który działa w ANTLR dla C#. Chcesz taki przykład?

user
a jak sie dodawalo namespace Generated do antrl?

ChatGPT
W ANTLR dla C# nie ma bezpośredniej flagi -namespace, ale można to zrobić dwoma sposobami:



1. Flaga -package (przy generowaniu C#)
W C# flaga -package działa jak namespace. Przykład:


antlr4 -Dlanguage=CSharp -o Generated -package Generated -visitor RaceLang.g4



Efekt: w wygenerowanych plikach C# będzie:


namespace Generated {
    public class RaceLangParser : Parser { ... }
    public class RaceLangLexer : Lexer { ... }
}





2. Ręczna edycja @header w gramatyce
Możesz też w gramatyce dodać nagłówek z namespace:


grammar RaceLang;

@header {
namespace Generated;
}



To wstrzyknie namespace Generated; do wszystkich wygenerowanych plików C#.



💡 Tip: Jeśli używasz -visitor, też automatycznie trafi do tego samego namespace.



Jeśli chcesz, mogę Ci zrobić przykładową kompletną komendę ANTLR dla C# z folderem Generated, visitorami i namespace, gotową do użycia. Chcesz?

Struktury w C

user
struct RigidBody {
    pos: vec3;
    vel: vec3;
    mass: f32;
}
na c

ChatGPT
W C nie masz struktur z polami nazwanych jak w Rust/GLSL, ale możesz to przełożyć tak:


typedef struct {
    float x, y, z;
} vec3;

typedef struct {
    vec3 pos;
    vec3 vel;
    float mass;
} RigidBody;



Wtedy możesz używać tak:


RigidBody rb = {
    .pos = {0.0f, 0.0f, 0.0f},
    .vel = {1.0f, 0.0f, 0.0f},
    .mass = 10.0f
};



Chcesz żebym też dorzucił proste funkcje pomocnicze do operacji na vec3 (dodawanie, mnożenie przez skalar itp.), żeby to przypominało Rustowe podejście?

user
ale             "vec3" =>
na co mam zmapowac

ChatGPT
vec3 to w Twoim przykładzie taki typ skrótowy na 3-wymiarowy wektor liczb zmiennoprzecinkowych. W czystym C nie ma takiego typu, więc masz kilka opcji mapowania:
Struktura (najczytelniejsze, klasyczne rozwiązanie)

typedef struct {
    float x, y, z;
} vec3;


Tablica (bardziej „surowe” podejście, ale prostsze w operacjach iteracyjnych)

typedef float vec3[3];


float[3] inline w strukturze (bez aliasu)

typedef struct {
    float pos[3];
    float vel[3];
    float mass;
} RigidBody;





Najczęściej w silnikach gier i fizyce stosuje się wariant 1 (struct), bo jest czytelny i łatwo rozszerzalny (np. można dodać funkcje pomocnicze).
W shaderach (GLSL/HLSL) spotykasz wariant 2 (tablica albo wbudowany vec3).

👉 Do C polecałbym mapować vec3 na struct { float x,y,z; }.

Chcesz, żebym przygotował Ci gotowy zestaw aliasów (vec2, vec3, vec4) jak w GLSL, żebyś miał drop-in replacement?

user
    string MapType(string raceType) =>
        raceType switch
        {
            "i32" => "int",
            "f32" => "float",
            "string" => "char *",
            "vec3" =>
            _ => "unknown type",
        };

ChatGPT
W tym mapperze możesz spokojnie dopisać "vec3" → "struct vec3", zakładając że wcześniej masz zdefiniowaną strukturę vec3.

Na przykład:


string MapType(string raceType) =>
    raceType switch
    {
        "i32"    => "int",
        "f32"    => "float",
        "string" => "char *",
        "vec3"   => "struct vec3",
        _        => "unknown type",
    };



I w kodzie C musisz mieć wcześniej:


typedef struct vec3 {
    float x, y, z;
} vec3;





💡 Alternatywa: jeśli chcesz, żeby kod wygenerowany używał tylko vec3 (bez struct przed), to w mapperze daj "vec3" => "vec3", a w C zdefiniuj typ przez typedef jak wyżej.

Chcesz żebym rozpisał oba warianty (z struct vec3 i z aliasem typedef), żebyś wiedział który lepiej pasuje do generatora?

user
jeszcze raz tamta struct Rigidbody na c

ChatGPT
Jasne — pełna, poprawna wersja w czystym C z vec3 jako osobnym typem:


#include <stdio.h>

// Definicja wektora 3D
typedef struct {
    float x;
    float y;
    float z;
} vec3;

// Definicja rigidbody
typedef struct {
    vec3 pos;   // pozycja
    vec3 vel;   // prędkość
    float mass; // masa
} RigidBody;

int main() {
    RigidBody rb = {
        .pos = {0.0f, 0.0f, 0.0f},
        .vel = {1.0f, 0.0f, 0.0f},
        .mass = 10.0f
    };

    printf("pos=(%.2f, %.2f, %.2f), mass=%.2f\n",
           rb.pos.x, rb.pos.y, rb.pos.z, rb.mass);

    return 0;
}



👉 Dzięki typedef możesz pisać po prostu vec3 zamiast struct vec3.

Chcesz żebym dorzucił też funkcje pomocnicze dla vec3 (np. dodawanie, mnożenie przez skalar), żebyś miał gotowe narzędzia jak w GLSL/Rust?

user
ale z race na c

ChatGPT
Aaa, rozumiem 🙂 — chcesz bezpośrednie tłumaczenie z Twojego RaceLang przykładu:

RaceLang:

struct RigidBody {
    pos: vec3;
    vel: vec3;
    mass: f32;
}



Na C (wygenerowany kod):

typedef struct {
    float x;
    float y;
    float z;
} vec3;

typedef struct {
    vec3 pos;
    vec3 vel;
    float mass;
} RigidBody;



Czyli:
struct → typedef struct {...} Name;
vec3 → vec3 (osobno zdefiniowany typ)
f32 → float



Chcesz, żebym rozpisał Ci ogólną regułę mapowania RaceLang → C dla struktur (np. jak traktować i32, string, inne wektory vec2/vec4), żebyś miał to jako szablon dla generatora?

user
czyli             "vec3" => "vec3"

ChatGPT
Dokładnie tak ✅

Jeśli w kodzie C masz wcześniej zrobione:


typedef struct {
    float x, y, z;
} vec3;



to w mapperze wystarczy:


"vec3" => "vec3",



Dzięki typedef nie musisz pisać "struct vec3", tylko używasz krótszej formy.

Chcesz, żebym przygotował Ci od razu pełną tabelkę mapowań Race → C (i32, f32, string, vec2, vec3, vec4 itd.), żebyś miał komplet?

user
typedef struct{
vec3 pos;
vec3 vel;
float mass;
} RigidBody;

ChatGPT
Tak, to jest poprawne i w pełni zgodne z tym, co chcesz osiągnąć.
Dla kompletności trzeba tylko pamiętać, że gdzieś wyżej w kodzie musisz mieć zdefiniowane vec3, np.:


typedef struct {
    float x;
    float y;
    float z;
} vec3;



Wtedy Twoja definicja:


typedef struct {
    vec3 pos;
    vec3 vel;
    float mass;
} RigidBody;



działa poprawnie i możesz używać:


RigidBody rb = {
    .pos = {0.0f, 0.0f, 0.0f},
    .vel = {1.0f, 0.0f, 0.0f},
    .mass = 10.0f
};



👉 Chcesz, żebym dorzucił Ci wersję RigidBody i vec3 w jednym bloku (tak, żeby było gotowe do wklejenia bez dodatkowych typedefów)?

user
czyli musze dogenerowac struct vec3 ale jak

ChatGPT
Dokładnie 🙂 — żeby generator wygenerował poprawny kod w C, musisz najpierw wygenerować definicję vec3.

Najprostszy wariant to wrzucenie na początek kodu C:


typedef struct {
    float x;
    float y;
    float z;
} vec3;



I wtedy mapper zostaje:


"vec3" => "vec3",





👉 W praktyce w generatorze możesz to zrobić na dwa sposoby:
Stała biblioteka typów
   Zawsze dołączasz na początku wygenerowanego pliku fragment z definicją vec2, vec3, vec4 itd. – coś jak „runtime” dla RaceLang.
   

   typedef struct { float x, y; } vec2;
   typedef struct { float x, y, z; } vec3;
   typedef struct { float x, y, z, w; } vec4;
   

Lazy generation
   Generator sprawdza, czy w kodzie pojawił się typ vec3, i jeśli tak – dokleja jego definicję do wygenerowanego pliku (ale tylko raz).



Mam pytanie: chcesz, żebym przygotował Ci gotowy blok “runtime” dla Race → C (wszystkie podstawowe typy vec2, vec3, vec4, może też mat4), który zawsze możesz includować zamiast dorzucać ręcznie?

user
typedef struct{
vec3 pos;
vec3 vel;
float mass;
} RigidBody;

Engine myEngine = {
.horsepower = 450,
.torque = 550.5
};

jak poprawic na to powyzej

ChatGPT
Teraz problem jest taki, że używasz Engine, ale nigdzie wcześniej nie zdefiniowałeś takiej struktury 🙂.
Żeby taki kod się kompilował, musisz najpierw wygenerować definicję Engine.

Przykład kompletny:


#include <stdio.h>

// --- definicje typów wektorowych ---
typedef struct {
    float x, y, z;
} vec3;

// --- definicja rigidbody ---
typedef struct {
    vec3 pos;
    vec3 vel;
    float mass;
} RigidBody;

// --- definicja engine ---
typedef struct {
    int horsepower;
    float torque;
} Engine;

int main(void) {
    RigidBody rb = {
        .pos = {0.0f, 0.0f, 0.0f},
        .vel = {1.0f, 0.0f, 0.0f},
        .mass = 10.0f
    };

    Engine myEngine = {
        .horsepower = 450,
        .torque = 550.5f
    };

    printf("RigidBody mass: %.2f\n", rb.mass);
    printf("Engine: %d HP, %.2f Nm\n", myEngine.horsepower, myEngine.torque);

    return 0;
}





👉 Czyli poprawka do Twojego kodu:
dopisz definicję Engine zanim zrobisz Engine myEngine = {...};
pamiętaj, żeby wartości zmiennoprzecinkowe w C mieć z sufiksem f (np. 550.5f)

Chcesz, żebym rozpisał ogólną regułę: jak RaceLang-owy struct zawsze mapować na typedef struct { ... } Name; w C, żeby takie przypadki jak RigidBody i Engine generowały się automatycznie?

user
mam typedef struct{
int horsepower;
float torque;
} Engine;

ChatGPT
Super 👍 — czyli definicja Engine już jest poprawna:


typedef struct {
    int horsepower;
    float torque;
} Engine;



Teraz inicjalizacja, żeby była w pełni poprawna w C, powinna wyglądać tak:


Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f   // ← pamiętaj o <code>f</code> przy liczbie zmiennoprzecinkowej
};





Czyli razem z Twoim RigidBody:


typedef struct {
    float x, y, z;
} vec3;

typedef struct {
    vec3 pos;
    vec3 vel;
    float mass;
} RigidBody;

typedef struct {
    int horsepower;
    float torque;
} Engine;

RigidBody rb = {
    .pos = {0.0f, 0.0f, 0.0f},
    .vel = {1.0f, 0.0f, 0.0f},
    .mass = 10.0f
};

Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f
};





👉 Czy chcesz, żebym Ci zrobił gotowy szablon generatora w C#, który tłumaczy każdy struct z RaceLang (np. RigidBody, Engine, Car) na takiego typedef struct { ... } Name; w C, wraz z inicjalizacją?

user
ale w miejsce Engine wskakuje mi Rigidbody

ChatGPT
Aha, czyli w Twoim generatorze zamiast wygenerować:


Engine myEngine = { ... };



dostajesz:


RigidBody myEngine = { ... };



To oznacza, że mapper typów nie zamapował RaceLang-owego Engine na C, tylko wziął domyślnie struct z nazwą pola.

W C# w funkcji mapującej typy musisz dopisać Engine:


string MapType(string raceType) =>
    raceType switch
    {
        "i32"    => "int",
        "f32"    => "float",
        "string" => "char *",
        "vec3"   => "vec3",
        "Engine" => "Engine",   // <- tu jest kluczowe
        _        => "unknown type",
    };



Wtedy generator wygeneruje poprawnie:


Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f
};





Jeśli chcesz, mogę Ci zrobić pełną mapę RaceLang → C dla wszystkich typów, żeby nie zdarzało się, że jakiś struct wpadnie w domyślny RigidBody.

user
ja mysle ze tu jest problem         sb.AppendLine($"{structDeclName} {engineInstance?.Name} = {{");

ChatGPT
Aha, teraz wszystko jasne 🙂

Problem nie jest w mapowaniu typów, tylko w tym, co wstawiasz jako nazwę typu w wygenerowanym C.

Linijka:


sb.AppendLine($"{structDeclName} {engineInstance?.Name} = {{");


structDeclName to właśnie nazwa struktury, którą generator uważa za domyślną.
Jeśli generator nie ustawia structDeclName poprawnie dla Engine, to zostaje np. RigidBody.

W praktyce musisz upewnić się, że structDeclName bierze typ RaceLang, a nie np. nazwę pola lub jakąś domyślną strukturę.

Np. w generatorze powinno być coś w stylu:


string structDeclName = MapType(raceStruct.TypeName);



gdzie raceStruct.TypeName to "Engine" lub "RigidBody", a MapType robi mapowanie Race → C ("Engine" => "Engine").

Wtedy Twój sb.AppendLine stanie się:


Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f
};





Chcesz, żebym rozpisał przykład całego fragmentu generatora, który generuje C dla dowolnego struct z RaceLang wraz z inicjalizacją pola, tak żeby nie przepisywało RigidBody zamiast np. Engine?

user
tak

ChatGPT
Jasne, mogę pokazać prosty, kompletny fragment generatora w C# dla RaceLang → C, który poprawnie generuje każdy struct z inicjalizacją pola, bez „przypadkowego” RigidBody.

Przykład:


using System.Text;

// Klasa reprezentująca pole w strukturze RaceLang
class Field
{
    public string Name;
    public string Type;
    public string DefaultValue; // np. "0.0f", "{0,0,0}" itp.
}

// Klasa reprezentująca strukturę RaceLang
class RaceStruct
{
    public string TypeName;       // np. "RigidBody" lub "Engine"
    public Field[] Fields;
}

// Mapper RaceLang -> C
string MapType(string raceType) => raceType switch
{
    "i32"    => "int",
    "f32"    => "float",
    "string" => "char *",
    "vec2"   => "vec2",
    "vec3"   => "vec3",
    "vec4"   => "vec4",
    "Engine" => "Engine",
    "RigidBody" => "RigidBody",
    _        => "unknown_type"
};

// Funkcja generująca C dla struktury + inicjalizację pola
string GenerateStructInstance(RaceStruct raceStruct, string instanceName)
{
    var sb = new StringBuilder();

    // typ w C
    string structDeclName = MapType(raceStruct.TypeName);

    sb.AppendLine($"{structDeclName} {instanceName} = {{");

    foreach (var field in raceStruct.Fields)
    {
        string defaultValue = field.DefaultValue ?? "0"; // fallback
        sb.AppendLine($"    .{field.Name} = {defaultValue},");
    }

    sb.AppendLine("};\n");
    return sb.ToString();
}

// --- przykładowe użycie ---
var engineStruct = new RaceStruct
{
    TypeName = "Engine",
    Fields = new[]
    {
        new Field { Name = "horsepower", Type = "i32", DefaultValue = "450" },
        new Field { Name = "torque", Type = "f32", DefaultValue = "550.5f" }
    }
};

string generatedC = GenerateStructInstance(engineStruct, "myEngine");
Console.WriteLine(generatedC);



Wygenerowany C będzie dokładnie taki:


Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f,
};



✅ Kilka kluczowych rzeczy:
MapType tłumaczy tylko nazwę typu, nie nazwę pola.
structDeclName = MapType(raceStruct.TypeName) – dzięki temu zawsze trafnie wybiera typ (Engine, RigidBody itd.)
Każde pole jest inicjalizowane z DefaultValue.
Wygenerowany kod C jest poprawny składniowo i można go wprost kompilować.



Mogę też przygotować wersję rozszerzoną, która obsługuje automatycznie typy vec2/vec3/vec4 i generuje ich inicjalizację w formacie {0.0f, 0.0f, 0.0f}, żeby Twój generator Race → C był „gotowy do użycia” na wszystkie typy.

Chcesz, żebym to zrobił?

user
    public string GenEngineInstance(EngineInstanceNode engineInstance)
    {
        var sb = new StringBuilder();

        sb.AppendLine($"{structDeclName} {engineInstance?.Name} = {{");
        if (engineInstance.Fields != null)
        {
            int index = 0;
            foreach (var f in engineInstance.Fields)
            {
                if (f != null)
                {
                    // Console.WriteLine($"[DEBUG] Field: {f.Name},");

                    int last = engineInstance.Fields.Count - 1;
                    // with comma
                    if (index < last)
                    {
                        sb.AppendLine(GenFieldValue(f, true));
                    }
                    else
                    {
                        sb.AppendLine(GenFieldValue(f, false));
                    }
                    index++;
                }
            }
        }
        sb.AppendLine("};");
        return sb.ToString();
    }

ChatGPT
Ok, teraz widzę dokładnie, gdzie jest problem 🙂

W Twojej funkcji:


sb.AppendLine($"{structDeclName} {engineInstance?.Name} = {{");



structDeclName nie jest zdefiniowane w tej funkcji, więc najpewniej bierze wartość z zewnątrz albo zostaje domyślnie ustawione na RigidBody. Dlatego w wygenerowanym kodzie masz:


RigidBody myEngine = { ... };



a nie:


Engine myEngine = { ... };





Rozwiązanie: musisz w funkcji przypisać structDeclName na podstawie typu engineInstance, np.:


public string GenEngineInstance(EngineInstanceNode engineInstance)
{
    var sb = new StringBuilder();

    // <-- dodaj mapowanie typu tutaj
    string structDeclName = MapType(engineInstance.TypeName); // np. "Engine"

    sb.AppendLine($"{structDeclName} {engineInstance?.Name} = {{");

    if (engineInstance.Fields != null)
    {
        int index = 0;
        foreach (var f in engineInstance.Fields)
        {
            if (f != null)
            {
                int last = engineInstance.Fields.Count - 1;
                // z przecinkiem
                if (index < last)
                {
                    sb.AppendLine(GenFieldValue(f, true));
                }
                else
                {
                    sb.AppendLine(GenFieldValue(f, false));
                }
                index++;
            }
        }
    }

    sb.AppendLine("};");
    return sb.ToString();
}



Kluczowe:
engineInstance.TypeName musi zawierać dokładną nazwę RaceLang-owego typu (Engine lub RigidBody).
MapType tłumaczy Race → C ("Engine" => "Engine", "vec3" => "vec3" itd.).

Po tej poprawce Twój generator powinien wygenerować:


Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f
};





Jeśli chcesz, mogę Ci przepisać pełną funkcję GenEngineInstance z obsługą wszystkich typów RaceLang, żeby nie trzeba było ręcznie dopisywać nowych typów i zawsze trafiało na poprawny structDeclName. Chcesz, żebym to zrobił?

user
 if (fieldDecl.Type == "vec3")
        {
            var sb = new StringBuilder();
            sb.Insert("typedef".IndexOf() - 1, $@"typedef struct {
    float x, y, z;
} vec3;");

ChatGPT
Ok, teraz widzę, co próbujesz zrobić 🙂

Linijka:


sb.Insert("typedef".IndexOf() - 1, $@"typedef struct {
    float x, y, z;
} vec3;");



ma kilka problemów:
StringBuilder.Insert wymaga indeksu liczbowego, a "typedef".IndexOf() nie istnieje — IndexOf wymaga argumentu, np. "typedef".IndexOf("t"). Poza tym "typedef" to po prostu literał, nie string w buforze.
Nawet gdybyś poprawił składnię, wstawianie typedef struct vec3 w środku generowanego kodu w losowym miejscu nie jest dobre — lepiej dodać na początek pliku, zanim pojawi się jakikolwiek vec3.
Twój generator powinien dodać typedef tylko raz, nawet jeśli w kodzie jest kilka vec3.



Prosta, poprawna metoda:


// na początku generatora
private bool vec3Declared = false;

public void EnsureVec3Declared(StringBuilder sb)
{
    if (!vec3Declared)
    {
        sb.Insert(0, @"typedef struct {
    float x, y, z;
} vec3;

"); // wstaw na początek
        vec3Declared = true;
    }
}



W funkcji generującej pola:


if (fieldDecl.Type == "vec3")
{
    EnsureVec3Declared(sb);
}



Dzięki temu:
vec3 będzie zadeklarowany przed użyciem,
deklaracja pojawi się tylko raz,
nie musisz kombinować z dziwnym Insert("typedef".IndexOf() - 1, ...).



Chcesz, żebym zrobił też wersję dla wszystkich typów wektorowych (vec2, vec3, vec4), żeby generator automatycznie dodawał typedefy tylko raz?

user
    string GenVec3()
    {
        return @"typedef struct {
    float x, y, z;
} vec3;";
    }
    public string GenFieldDecl(FieldDeclNode fieldDecl)
    {
        if (fieldDecl.Type == "vec3")
        {
            var sb = new StringBuilder();
            sb.Insert(0, GenVec3());

        }
        return $"{MapType(fieldDecl.Type)} {fieldDecl.Name};";
    }

ChatGPT
Teraz widzę problem w Twojej funkcji:


public string GenFieldDecl(FieldDeclNode fieldDecl)
{
    if (fieldDecl.Type == "vec3")
    {
        var sb = new StringBuilder();
        sb.Insert(0, GenVec3());
    }
    return $"{MapType(fieldDecl.Type)} {fieldDecl.Name};";
}



Co się dzieje:
Tworzysz StringBuilder i wstawiasz typedef vec3, ale nigdy nie zwracasz tego stringa.
Funkcja zawsze kończy się na return $"{MapType(fieldDecl.Type)} {fieldDecl.Name};";, więc typedef jest ignorowany.
Każde wywołanie dla pola typu vec3 będzie próbowało wstawiać typedef, nawet jeśli już został wstawiony — niekontrolowane duplikaty.



Poprawiony sposób (tylko raz deklarujesz typedef na początek, reszta pól generowana normalnie):


private bool vec3Declared = false;

string GenVec3()
{
    return @"typedef struct {
    float x, y, z;
} vec3;

";
}

public string GenFieldDecl(FieldDeclNode fieldDecl, StringBuilder sb)
{
    // wstaw typedef tylko raz na początek bufora
    if (fieldDecl.Type == "vec3" && !vec3Declared)
    {
        sb.Insert(0, GenVec3());
        vec3Declared = true;
    }

    return $"{MapType(fieldDecl.Type)} {fieldDecl.Name};";
}



Użycie:


var sb = new StringBuilder();
foreach(var field in structNode.Fields)
{
    sb.AppendLine(GenFieldDecl(field, sb));
}



✅ Efekt:
typedef vec3 pojawia się tylko raz na początku generowanego kodu.
Każde pole vec3 generuje poprawną deklarację pola w strukturze.
Działa też w przypadku wielu struktur zawierających vec3.



Mogę Ci zrobić pełny wzorzec dla vec2/vec3/vec4, który generuje typedefy tylko raz i działa dla wszystkich pól w dowolnej strukturze RaceLang. Chcesz, żebym to zrobił?

user
 public string GenFieldDecl(FieldDeclNode fieldDecl)
    {
        if (fieldDecl.Type == "vec3")
        {
            var sb = new StringBuilder();
            sb.Insert(0, GenVec3());


        }
        return $"{MapType(fieldDecl.Type)} {fieldDecl.Name};";
    }

nie wstawia sb.Insert(0, GenVec3());
            

ChatGPT
Dokładnie, teraz problem jest jasny 🙂

Twój kod:


var sb = new StringBuilder();
sb.Insert(0, GenVec3());



nie działa tak, jak się spodziewasz, bo tworzysz nowy StringBuilder, wstawiasz do niego vec3, a potem… go porzucasz. Funkcja dalej kończy się na:


return $"{MapType(fieldDecl.Type)} {fieldDecl.Name};";



czyli ten sb w ogóle nie jest użyty ani zwrócony.



Poprawne podejście:
Nie twórz nowego StringBuilder w GenFieldDecl — zamiast tego wstaw typedef do głównego bufora generowanego pliku.
Zrób flagę, żeby deklaracja vec3 była dodana tylko raz.

Przykład:


private bool vec3Declared = false;

string GenVec3() => @"typedef struct {
    float x, y, z;
} vec3;

";

public void GenFieldDecl(FieldDeclNode fieldDecl, StringBuilder sb)
{
    // dodaj typedef tylko raz na początek
    if (fieldDecl.Type == "vec3" && !vec3Declared)
    {
        sb.Insert(0, GenVec3());
        vec3Declared = true;
    }

    sb.AppendLine($"{MapType(fieldDecl.Type)} {fieldDecl.Name};");
}



Użycie:


var sb = new StringBuilder();
foreach (var field in structNode.Fields)
{
    GenFieldDecl(field, sb);
}



✅ Efekt:
typedef vec3 pojawia się tylko raz na początku.
Pola vec3 są generowane poprawnie w strukturze.
Nie tworzysz niepotrzebnego StringBuilder w każdej iteracji.



Jeżeli chcesz, mogę Ci przygotować kompletny generator typów wektorowych (vec2/vec3/vec4) w tym samym stylu, który zawsze deklaruje typedef tylko raz i działa dla wielu struktur. Chcesz, żebym to zrobił?

user
ok dziala jeszcze poprawic unknown type myEngine

ChatGPT
Jasne 🙂 Problem z unknown type w wygenerowanym C wynika z tego, że Twój mapper Race → C nie rozpoznaje danego typu.
Upewnij się, że MapType zawiera wszystkie struktury, które chcesz używać, np.:


string MapType(string raceType) => raceType switch
{
    "i32"       => "int",
    "f32"       => "float",
    "string"    => "char *",
    "vec2"      => "vec2",
    "vec3"      => "vec3",
    "vec4"      => "vec4",
    "RigidBody" => "RigidBody",
    "Engine"    => "Engine",   // <-- tutaj kluczowe
    _           => "unknown_type"
};


W funkcji generującej instancję upewnij się, że bierzesz typ struktury, a nie nazwę pola:


string structDeclName = MapType(engineInstance.TypeName); // TypeName = "Engine"


Wtedy generowane będzie:


Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f
};





💡 W skrócie:
Każdy RaceLang-owy struct, który chcesz użyć, musi być w MapType.
structDeclName w generatorze instancji musi pochodzić z pola typu (np. TypeName w AST), a nie z nazwy pola.

Jeżeli chcesz, mogę Ci napisać pełną, gotową funkcję generatora instancji, która obsługuje wszystkie typy RaceLang (i32/f32/string/vec2/vec3/vec4/RigidBody/Engine) i nigdy nie wstawia unknown_type. Chcesz, żebym to zrobił?

user
  public string GenEngineInstance(EngineInstanceNode engineInstance)
    {
        var sb = new StringBuilder();



        string structDeclName = MapType(engineInstance.Kind);

        sb.AppendLine($"{structDeclName} {engineInstance?.Name} = {{");
  

ChatGPT
Dokładnie 🙂 — tu widać problem:


string structDeclName = MapType(engineInstance.Kind);


Jeśli engineInstance.Kind nie jest dokładnie "Engine", tylko np. "engine" albo jakimś sposobem "RigidBody" w AST, to MapType zwróci "unknown_type".
Dlatego w wygenerowanym C dostajesz:


unknown_type myEngine = { ... };





Poprawka:
Upewnij się, że engineInstance.Kind zawiera dokładną nazwę struktury RaceLang, np. "Engine".
Twój MapType musi mieć wpis:


"Engine" => "Engine",


Wtedy kod:


string structDeclName = MapType(engineInstance.Kind);
sb.AppendLine($"{structDeclName} {engineInstance?.Name} = {{");



wygeneruje poprawnie:


Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f
};





💡 Dodatkowo warto:
zrobić mapę Race → C raz na początku (np. Dictionary<string,string>), żeby uniknąć literówek,
jeśli typ nie istnieje, rzucać wyjątkiem lub logować błąd, zamiast wrzucać "unknown_type".

Jeżeli chcesz, mogę Ci przepisać pełną funkcję GenEngineInstance, która działa dla każdego struct z RaceLang, poprawnie mapuje typy i automatycznie dodaje typedefy wektorów (vec3 itd.). Chcesz, żebym to zrobił?

user
            _ => Console.WriteLine("unknown type")

ChatGPT
Takie użycie:


_ => Console.WriteLine("unknown type")



w wyrażeniu switch, które ma zwracać string, nie zadziała – Console.WriteLine zwraca void, a switch musi zwracać string. Stąd mogą brać się dziwne wartości typu unknown_type.

Poprawny sposób to np.:


string MapType(string raceType) => raceType switch
{
    "i32"       => "int",
    "f32"       => "float",
    "string"    => "char *",
    "vec2"      => "vec2",
    "vec3"      => "vec3",
    "vec4"      => "vec4",
    "RigidBody" => "RigidBody",
    "Engine"    => "Engine",
    _           => throw new Exception($"Unknown type: {raceType}")
};



Lub jeśli nie chcesz wyjątku:


_ => "unknown_type"



ale wtedy nie używaj Console.WriteLine, bo zwracana wartość switcha musi być stringiem.



💡 Możesz też logować i zwracać:


_ => { Console.WriteLine($"Unknown type: {raceType}"); return "unknown_type"; }



To jedyna poprawna forma, jeśli chcesz wypisywać komunikat i zwracać string.

Chcesz, żebym przepisał Twój MapType w pełni poprawnie pod generator Race → C z logowaniem błędów?

user
jak mam sie dostac do wartosci torque

ChatGPT
Masz na myśli w C (wygenerowany kod), czy w C# generatorze podczas budowania inicjalizacji?



🔹 Wygenerowany C
Jeśli masz:


typedef struct {
    int horsepower;
    float torque;
} Engine;

Engine myEngine = {
    .horsepower = 450,
    .torque = 550.5f
};



to dostęp robisz klasycznie przez kropkę:


printf("%d\n", myEngine.horsepower);
printf("%f\n", myEngine.torque);





🔹 W C# generatorze (AST → C)
Zakładam, że engineInstance.Fields zawiera węzły pól (FieldInitNode albo coś podobnego).
Przykład Twojego fragmentu:


foreach (var f in engineInstance.Fields)
{
    sb.AppendLine(GenFieldValue(f, index < last));
}



Jeżeli f.Name == "torque", to w metodzie GenFieldValue masz do niej dostęp normalnie:


public string GenFieldValue(FieldInitNode f, bool withComma)
{
    string value = f.Value; // np. "550.5"
    string comma = withComma ? "," : "";
    return $".{f.Name} = {value}{comma}";
}



Wtedy generator wygeneruje:


.torque = 550.5f





👉 Pytanie do Ciebie: chodzi Ci o dostęp w runtime w C (np. myEngine.torque), czy o dostęp w generatorze w C# (np. odczytanie wartości pola torque z AST)?

user
    println("engine torque: ", myEngine.torque);

ChatGPT
Okej, to już jasne 🙂 — chcesz w RaceLang pisać:


println("engine torque: ", myEngine.torque);



i żeby to się przełożyło na C.



Jak to powinno wyglądać w wygenerowanym C
To musi wypluć coś w stylu:


printf("engine torque: %f\n", myEngine.torque);





Jak to zrobić w generatorze
Rozpoznaj MemberAccess w AST
   Jeśli parser zwróci coś typu MemberAccessNode { Expr = "myEngine", Member = "torque" }, to w generatorze trzeba to obsłużyć.
W generatorze println
   Wtedy zamiast wprost printf("...", ...) musisz sprawdzić, czy argument nie jest MemberAccess.
   Jeśli tak, to wygenerować myEngine.torque.

Przykład schematu:


public string GenPrintln(PrintlnNode node)
{
    var sb = new StringBuilder();

    sb.Append("printf(\"");
    sb.Append(node.Args[0].Value); // "engine torque: "
    sb.Append(" %f\\n\", ");

    // Drugi argument – np. MemberAccessNode
    var second = node.Args[1];
    if (second is MemberAccessNode ma)
    {
        sb.Append($"{ma.Expr}.{ma.Member}");
    }
    else
    {
        sb.Append(second.Value);
    }

    sb.AppendLine(");");

    return sb.ToString();
}





Efekt końcowy
RaceLang:


println("engine torque: ", myEngine.torque);



Wygenerowany C:


printf("engine torque: %f\n", myEngine.torque);





👉 Chcesz, żebym rozpisał Ci kompletny przykład obsługi MemberAccess w generatorze (dla myEngine.torque i podobnych przypadków)?

user
ale chodzi mi skad mam wziac wartosc myEngine.torque

ChatGPT
Aaa, rozumiem 👍 — pytasz nie o to, jak wygenerować kod z myEngine.torque, tylko skąd w generatorze wziąć tę wartość (czyli 550.5).



Jak to wygląda w Twoim AST
Masz definicję instancji:


Engine myEngine = {
    horsepower = 450,
    torque = 550.5
};



W AST to powinno być coś takiego:


EngineInstanceNode {
    Name = "myEngine",
    Kind = "Engine",
    Fields = [
        FieldInitNode { Name = "horsepower", Value = "450" },
        FieldInitNode { Name = "torque", Value = "550.5" }
    ]
}





Jak obsłużyć myEngine.torque
Kiedy parser spotka myEngine.torque, dostajesz MemberAccessNode:


MemberAccessNode {
    Expr = "myEngine",
    Member = "torque"
}



Żeby dostać wartość:
Znajdujesz instancję o nazwie myEngine w swojej tablicy symboli / liście instancji.
np. EngineInstanceNode instance = instances.First(i => i.Name == "myEngine");
Szukasz pola torque w instance.Fields.
np. FieldInitNode field = instance.Fields.First(f => f.Name == "torque");
Odczytujesz wartość → field.Value → "550.5".



Przykładowy kod w C#

string GetFieldValue(string instanceName, string member)
{
    var instance = instances.FirstOrDefault(i => i.Name == instanceName);
    if (instance == null)
        throw new Exception($"Unknown instance: {instanceName}");

    var field = instance.Fields.FirstOrDefault(f => f.Name == member);
    if (field == null)
        throw new Exception($"Unknown field: {member} in {instanceName}");

    return field.Value; // np. "550.5"
}



Wywołanie:


string torqueVal = GetFieldValue("myEngine", "torque");
// torqueVal == "550.5"





👉 Pytanie: chcesz, żeby generator zawsze rozwijał myEngine.torque do wartości literalnej (550.5) już w kodzie C, czy żeby zostawiał to jako odwołanie do struktury (myEngine.torque) i dopiero runtime w C je obsługiwał?

user
aa a ja kombinowalem z parse tree to niewygodnie

ChatGPT
No właśnie 🙂 — grzebanie bezpośrednio w parse tree (konkretnie w kontekście ANTLR ctx) jest uciążliwe, bo musisz chodzić po dzieciach węzłów (ctx.GetChild(1) itd.) i ciężko się w tym połapać.

Dlatego standardowa droga to:
Parse Tree → AST
Robisz własne Visit* metody, które z parse tree budują Ci czyste węzły AST (EngineInstanceNode, MemberAccessNode, FieldInitNode itd.).
Parse tree zostaje tylko do budowy AST, a dalej już z nim nie pracujesz.
AST → CodeGen
W generatorze operujesz na prostych klasach (instance.Fields, member.Name), a nie na ctx.
Dzięki temu możesz łatwo zrobić lookup: np. instances["myEngine"].Fields["torque"].Value.



Czyli:
Parse tree → tylko raz przy budowaniu AST.
Generator → pracuje wyłącznie na AST, nigdy na ctx.



💡 Jeśli chcesz, mogę Ci rozpisać prosty symbol table (np. Dictionary<string, EngineInstanceNode> instances) i lookup dla myEngine.torque, żebyś już nie musiał grzebać w parse tree, tylko miał wygodne API w stylu:


var torqueVal = symbols["myEngine"].Fields["torque"];



Chcesz, żebym Ci to przygotował?

user
tak probowalem

 var astNode = VisitName_token(ctxNameToken);
            var node = astNode as IdentifierExprNode;
            if(node.Name == idExpr.Name){
                astNode.
           

ChatGPT
Aaa, widzę co kombinujesz 🙂 — czyli próbujesz już w visitorze (parse tree → AST) „dobrać się” do wartości. To jest właśnie ta niewygoda, o której pisałem — bo parse tree w tym momencie nie trzyma niczego gotowego, tylko surowe tokeny.

Typowy workflow wygląda tak:



1. Budujesz czysty AST
W VisitMemberAccess (czyli coś jak myEngine.torque) zamiast próbować od razu „wyciągnąć wartość”, budujesz prosty węzeł AST:


public override AstNode VisitMember_access(RaceLangParser.Member_accessContext ctx)
{
    var target = Visit(ctx.expression()); // np. "myEngine"
    var member = ctx.IDENTIFIER().GetText(); // np. "torque"

    return new MemberAccessNode {
        Expr = target,
        Member = member
    };
}





2. Robisz symbol table
Podczas wizyty w VisitEngineInstance wrzucasz instancję do tabeli symboli:


public Dictionary<string, EngineInstanceNode> Instances { get; } = new();

public override AstNode VisitEngine_instance(RaceLangParser.Engine_instanceContext ctx)
{
    var instance = new EngineInstanceNode {
        Name = ctx.IDENTIFIER().GetText(),
        Kind = ctx.type().GetText(),
        Fields = ctx.fieldInit().Select(VisitFieldInit).ToList()
    };

    Instances[instance.Name] = instance;
    return instance;
}





3. Lookup przy generowaniu
Teraz w generatorze, jeśli dostaniesz MemberAccessNode { Expr = "myEngine", Member = "torque" }, to robisz:


if (node is MemberAccessNode ma)
{
    if (Instances.TryGetValue(ma.Expr.ToString(), out var inst))
    {
        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
        if (field != null)
        {
            // masz wartość jako string
            return field.Value;
        }
    }
    // fallback: zostaw referencję na runtime
    return $"{ma.Expr}.{ma.Member}";
}





4. Wygenerowany kod
RaceLang:

println("engine torque: ", myEngine.torque);



Wygenerowany C:

printf("engine torque: %f\n", 550.5f);



(albo, jeśli wolisz runtime: myEngine.torque).



👉 Chcesz, żebym Ci przygotował pełny przykład MemberAccessNode + symbol table + generator krok po kroku, tak żebyś miał działający lookup myEngine.torque → 550.5?

user
chcialem sie dostac do wartosci zeby wiedziec czy to float jesli tak to bedzie %.2f czaisz

ChatGPT
Aa, teraz wszystko jasne 😎 — chodzi Ci o dynamiczne dopasowanie formatu printf w C w zależności od typu pola (float, int itp.).



Jak to zrobić poprawnie
Symbol table z typami

Przy wstawianiu instancji do symboli, przechowuj nie tylko wartość, ale też typ:


public class FieldInitNode
{
    public string Name;
    public string Type;   // np. "i32", "f32", "vec3"
    public string Value;  // np. "450", "550.5"
}

public class EngineInstanceNode
{
    public string Name;
    public string Kind;   // np. "Engine"
    public List<FieldInitNode> Fields;
}


Lookup wartości i typu w generatorze

Kiedy trafiasz na MemberAccessNode:


if (node is MemberAccessNode ma)
{
    if (Instances.TryGetValue(ma.Expr.ToString(), out var inst))
    {
        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
        if (field != null)
        {
            string format = field.Type switch
            {
                "i32" => "%d",
                "f32" => "%.2f",
                _     => "%s"
            };
            return (format, field.Value);
        }
    }
}


Generowanie printf


var (fmt, val) = GetMemberFormatAndValue("myEngine", "torque");
sb.AppendLine($"printf(\"engine torque: {fmt}\\n\", {val});");



Efekt w C:


printf("engine torque: %.2f\n", 550.5f);





✅ Dzięki temu:
nie musisz zgadywać typów po samym MemberAccess,
zawsze wiesz, czy dać %d, %.2f czy %s,
możesz też obsłużyć inne typy (vec3, string itp.) w podobny sposób.



Jeżeli chcesz, mogę Ci napisać gotową funkcję helpera w C#, która bierze MemberAccessNode + symbol table i zwraca:
format printf
wartość literalną

do użycia w generatorze println.

Chcesz, żebym taką zrobił?

ChatGPT
Dokładnie 🙂 — tutaj najlepiej, żebyś w symbol table przechowywał nie tylko wartości pól, ale też ich typy. Wtedy, gdy napotkasz myEngine.torque w generatorze, możesz:
Znaleźć instancję myEngine w swojej tablicy symboli (np. Dictionary<string, EngineInstanceNode>).
Odnaleźć pole torque w myEngine.Fields.
Odczytać field.Type i field.Value.
Na podstawie typu dobrać format:


string printfFormat = field.Type switch
{
    "i32" => "%d",
    "f32" => "%.2f",
    _     => "%s"
};


Wygenerować C:


printf("engine torque: %.2f\n", 550.5f);



Takie podejście pozwala dynamicznie wiedzieć, czy wartość jest float, int czy string, bez grzebania w parse tree.

user
wrzucac nie chce 550.5f tylko chce dalej myEngine.torque

ChatGPT
Ah, teraz rozumiem 😎 — chcesz zostawić odwołanie do pola w strukturze (myEngine.torque) w wygenerowanym C, ale nadal wiedzieć w generatorze, jaki jest typ, żeby dobrać format w printf.



Jak to zrobić
Symbol table i typ pola

Twoja symbol table przechowuje instancje i typy pól, ale nie używasz wartości do wstawiania w kod:


public class FieldInitNode
{
    public string Name;
    public string Type;   // "i32", "f32", "vec3", itp.
    public string Value;  // można przechować, ale nie używamy w C
}

public class EngineInstanceNode
{
    public string Name;
    public string Kind;   // "Engine"
    public List<FieldInitNode> Fields;
}


Lookup w generatorze

Kiedy spotykasz myEngine.torque:


var ma = node as MemberAccessNode;
if (ma != null &amp;&amp; Instances.TryGetValue(ma.Expr, out var inst))
{
    var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
    if (field != null)
    {
        string printfFormat = field.Type switch
        {
            "i32" => "%d",
            "f32" => "%.2f",
            _     => "%s"
        };

        // tutaj zostawiasz odwołanie do pola w strukturze
        return (printfFormat, $"{ma.Expr}.{ma.Member}");
    }
}


Generowanie printf


var (fmt, valRef) = GetMemberFormatAndRef(myMemberNode);
sb.AppendLine($"printf(\"engine torque: {fmt}\\n\", {valRef});");



Wygenerowany C:


printf("engine torque: %.2f\n", myEngine.torque);



✅ Zalety:
W kodzie C zostaje odwołanie do struktury, nie literal.
W generatorze nadal masz info o typie, żeby dobrać format.
Możesz obsłużyć wszystkie pola struktur (i32, f32, vec3, itp.) w printf.



Jeśli chcesz, mogę Ci napisać kompletny helper w C#, który bierze MemberAccessNode + symbol table i zwraca format + odwołanie, gotowy do użycia w generatorze println.

Chcesz, żebym to zrobił?

user
var fieldValue = new FieldValueNode
        {
            Name = ctx.name_token().GetText(),
            Type = ctx.
        

ChatGPT
Aha, widzę 🙂 — jesteś w trakcie tworzenia FieldValueNode w visitorze i chcesz przypisać typ pola. W parse tree nie masz jeszcze bezpośrednio informacji o typie wartości (f32, i32 itd.), więc musisz to wywnioskować albo z deklaracji pola, albo z literalnego tokenu.

Przykład w visitorze:


var fieldValue = new FieldValueNode
{
    Name = ctx.name_token().GetText(),
    Value = ctx.value_token().GetText(), // np. "550.5" albo "450"
    Type = InferTypeFromCtx(ctx.value_token()) // helper, który zwraca "i32" / "f32" / "string"
};





Możliwe implementacje InferTypeFromCtx
Na podstawie tokenu literalnego:


string InferTypeFromCtx(RaceLangParser.Value_tokenContext ctx)
{
    var text = ctx.GetText();
    if (text.Contains("."))
        return "f32"; // liczba zmiennoprzecinkowa
    else if (int.TryParse(text, out _))
        return "i32"; // liczba całkowita
    else
        return "string"; // np. literał w cudzysłowie
}


Na podstawie deklaracji pola w strukturze
   Jeśli masz symbol table dla struktury, możesz znaleźć typ pola po jego nazwie i przypisać go w FieldValueNode.



💡 Dzięki temu w generatorze:
masz field.Type → możesz dobrać printf format (%d / %.2f),
nadal możesz zostawić w C odwołanie do pola, np. myEngine.torque.

Jeśli chcesz, mogę Ci zrobić pełny przykład VisitFieldInit, który tworzy FieldValueNode z Name, Value i Type gotowy do generatora. Chcesz, żebym to zrobił?

user
bo fieldDecl ma type ale fieldvalue nie

ChatGPT
Aha, teraz rozumiem dokładnie 🙂
FieldDeclNode → to jest deklaracja pola w strukturze, więc ma typ (i32, f32, vec3 itp.) i nazwę.
FieldValueNode → to jest inicjalizacja pola w instancji, czyli np. torque = 550.5, i sam w sobie nie ma typu.

Dlatego żeby wiedzieć, że np. myEngine.torque jest f32, musisz połączyć FieldValue z jego deklaracją w strukturze:



Jak to zrobić
Symbol table dla struktur


public class StructDeclNode
{
    public string Name;
    public List<FieldDeclNode> Fields; // tutaj każdy ma typ
}

Dictionary<string, StructDeclNode> Structs = new();


FieldValueNode


public class FieldValueNode
{
    public string Name;
    public string Value;
    public string Type; // nie jest w AST od razu, wypełniamy później
}


Łączenie typu w generatorze / podczas budowy AST

Kiedy tworzysz instancję:


var instance = new EngineInstanceNode
{
    Name = "myEngine",
    Kind = "Engine",
    Fields = ctx.fieldInit().Select(fvCtx => {
        var fv = new FieldValueNode
        {
            Name = fvCtx.name_token().GetText(),
            Value = fvCtx.value_token().GetText()
        };

        // znajdź typ w deklaracji struktury
        var structDecl = Structs["Engine"];
        fv.Type = structDecl.Fields.First(fd => fd.Name == fv.Name).Type;

        return fv;
    }).ToList()
};





✅ Efekt:
FieldValueNode teraz ma Type, mimo że w AST go pierwotnie nie było.
Generator może sprawdzić typ pola, np. f32 → %.2f.
Wygenerowany C może pozostać jako myEngine.torque, nie trzeba wrzucać literalnej wartości.



Jeżeli chcesz, mogę pokazać kompletny przykład generatora println, który bierze MemberAccessNode, patrzy na FieldValueNode.Type i wybiera format %d/%.2f/%s, zostawiając w kodzie odwołanie do myEngine.torque.

Chcesz, żebym to zrobił?

user
            ValueNode = new NumberLiteralExpr { Value = ctx.primary_expr().GetText() },

ChatGPT
Ah, teraz już rozumiem Twój kod 🙂

Masz coś w stylu:


ValueNode = new NumberLiteralExpr { Value = ctx.primary_expr().GetText() },


primary_expr() zwraca parse tree dla wartości.
GetText() daje Ci string literal "550.5" albo "450".
W tym momencie tworzysz NumberLiteralExpr, który sam w sobie nie ma typu (i32/f32) — masz tylko string.



Jak dorzucić typ
Na podstawie literalu:


var text = ctx.primary_expr().GetText();
string type = text.Contains(".") ? "f32" : "i32";

ValueNode = new NumberLiteralExpr
{
    Value = text,
    Type = type
};


Albo na podstawie deklaracji pola (lepiej, jeśli masz struct-symbol table):


var fieldDecl = structDecl.Fields.First(f => f.Name == fieldName);
ValueNode = new NumberLiteralExpr
{
    Value = ctx.primary_expr().GetText(),
    Type = fieldDecl.Type
};



Dzięki temu generator wie, że torque jest f32, nawet jeśli w C zostawiasz odwołanie myEngine.torque.



Chcesz, żebym zrobił fragment visitor + FieldValueNode + typ, który od razu tworzy węzeł gotowy do generatora printf z formatem?

user
jak sie moge do tego dostac structDecl w VisitField_value

ChatGPT
Aha, teraz jest jasne 🙂 – w VisitField_value chcesz wiedzieć, do jakiej struktury należy to pole, żeby odczytać typ z deklaracji (FieldDeclNode).

Parse tree nie przechowuje kontekstu rodzica, więc trzeba go przekazać ręcznie albo utrzymywać podczas wizyty. Standardowe rozwiązania:



1. Przekazywanie kontekstu struktury w visitorze

Dodajesz prywatne pole w visitorze, które mówi, która struktura jest aktualnie przetwarzana:


private StructDeclNode currentStruct;

public override AstNode VisitStruct_decl(RaceLangParser.Struct_declContext ctx)
{
    var structDecl = new StructDeclNode
    {
        Name = ctx.IDENTIFIER().GetText(),
        Fields = new List<FieldDeclNode>()
    };

    currentStruct = structDecl; // ustawiamy kontekst

    foreach (var fctx in ctx.field_decl())
    {
        var field = Visit(fctx) as FieldDeclNode;
        structDecl.Fields.Add(field);
    }

    currentStruct = null; // po wyjściu reset
    return structDecl;
}





2. W VisitField_value

Teraz masz dostęp do currentStruct:


public override AstNode VisitField_value(RaceLangParser.Field_valueContext ctx)
{
    var fieldName = ctx.name_token().GetText();
    var fieldDecl = currentStruct.Fields.First(f => f.Name == fieldName);

    var valueNode = new FieldValueNode
    {
        Name = fieldName,
        Value = ctx.primary_expr().GetText(),
        Type = fieldDecl.Type  // tutaj bierzesz typ
    };

    return valueNode;
}



✅ Dzięki temu:
nie musisz grzebać w parse tree w górę,
FieldValueNode dostaje typ pola, który możesz potem użyć w generatorze,
generator może zostawić w C myEngine.torque i dobrać format printf według Type.



Jeżeli chcesz, mogę Ci pokazać pełny przykład VisitStruct_decl + VisitField_value + symbol table, który działa dla dowolnej instancji i pól, razem z typami do generatora.

Chcesz, żebym to rozpisał?

user
ale po co w parse tree mam to w ast

ChatGPT
Dokładnie 🙂 — po to jest AST, żeby nie grzebać już w parse tree.

Parse tree jest „surowym” odwzorowaniem gramatyki: dzieci, tokeny, konteksty itd.
AST to czysta, logiczna reprezentacja programu, w której masz:


EngineInstanceNode myEngine {
    Name = "myEngine",
    Kind = "Engine",
    Fields = [
        FieldValueNode { Name = "horsepower", Type = "i32", Value = "450" },
        FieldValueNode { Name = "torque", Type = "f32", Value = "550.5" }
    ]
}





Dlaczego warto korzystać z AST zamiast parse tree
Łatwy dostęp do typów – np. FieldValueNode.Type bez szukania po rodzicach w parse tree.
Proste operacje w generatorze – możesz odwoływać się do myEngine.torque i wiedzieć, że to f32.
Brak zależności od kontekstu parsera – nie musisz pytać ctx.Parent albo ctx.GetChild(1).
Czytelny kod – visitor -> AST -> generator zamiast mieszać parse tree z logiką generowania kodu.



💡 Podsumowując:
Visitor buduje AST z parse tree.
Generator używa tylko AST, np. FieldValueNode.Type, MemberAccessNode.Expr itp.
Parse tree potem już nie jest potrzebne.

Jeżeli chcesz, mogę rozpisać pełny przykład jak z parse tree budujesz AST dla instancji Engine i pola torque, żeby generator miał od razu typy i wartości gotowe do użycia.

Chcesz, żebym to zrobił?

user
to mam dac VisitFieldDecl ?

ChatGPT
Tak, dokładnie — dla deklaracji pól w strukturze (np. int horsepower; float torque;) powinieneś mieć VisitFieldDecl, który tworzy w AST węzeł FieldDeclNode.

Przykładowo:


public override AstNode VisitField_decl(RaceLangParser.Field_declContext ctx)
{
    return new FieldDeclNode
    {
        Name = ctx.IDENTIFIER().GetText(),
        Type = ctx.type().GetText()   // np. "i32", "f32", "vec3"
    };
}





Kolejny krok
W VisitStruct_decl iterujesz po wszystkich field_decl() i wywołujesz VisitFieldDecl, żeby zbudować listę Fields w StructDeclNode.
Potem w VisitField_value możesz lookupować typ pola w currentStruct.Fields, jak wcześniej pokazywałem.

Czyli flow:

``
parse tree -> VisitStruct_decl -> VisitFieldDecl -> AST StructDeclNode + FieldDeclNode
parse tree -> VisitField_value -> AST FieldValueNode z Type z FieldDeclNode
`

Dzięki temu generator ma pełną informację o typach i może np. dobrać %.2f w printf dla myEngine.torque.



Chcesz, żebym rozpisał pełny przykład VisitStruct_decl + VisitFieldDecl + VisitField_value z typami gotowymi do generatora?

user
ale Type = VisitField_decl()

ChatGPT
Dokładnie 🙂 — w VisitField_value nie możesz samodzielnie wymyślić typu, bo on jest w deklaracji pola (FieldDeclNode).

Typowy sposób to:
W VisitStruct_decl budujesz listę pól i AST:



var structDecl = new StructDeclNode
{
    Name = ctx.IDENTIFIER().GetText(),
    Fields = ctx.field_decl().Select(fctx => VisitField_decl(fctx) as FieldDeclNode).ToList()
};


W VisitField_value lookupujesz typ pola w strukturze:



public override AstNode VisitField_value(RaceLangParser.Field_valueContext ctx)
{
    var fieldName = ctx.name_token().GetText();
    var fieldDecl = currentStruct.Fields.First(f => f.Name == fieldName);

    var valueNode = new FieldValueNode
    {
        Name = fieldName,
        Value = ctx.primary_expr().GetText(),
        Type = fieldDecl.Type  // <-- tutaj bierzesz typ z deklaracji
    };

    return valueNode;
}


VisitField_decl() zwraca FieldDeclNode z typem (i32, f32 itp.).

W VisitField_value używasz tej deklaracji, żeby wypełnić Type w FieldValueNode.




Czyli nie przypisujesz Type = VisitField_decl() bezpośrednio, tylko:
budujesz FieldDeclNode w VisitField_decl

w VisitField_value patrzysz w strukturę, która trzyma te deklaracje i bierzesz typ stamtąd.


Jeżeli chcesz, mogę rozpisać pełny przykład z currentStruct, FieldDeclNode i FieldValueNode, żeby było widać cały flow od struktury do wartości pola z typem.

Chcesz, żebym to zrobił?

user
                if (secondArg is MemberAccessNode ma)
                {

                    if (AstVisitor.Instances.TryGetValue(ma.Member, out var inst))
                    {
                        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
                        Console.WriteLine("field type " + field.Type);

                        if (field.Type == "f32")
                        {

                            str += "%.2f";
                        }

                        else
                        {

                            str += "%d";
                        }

ChatGPT
Aha, widzę błąd w Twoim kodzie 🙂

Masz:


if (AstVisitor.Instances.TryGetValue(ma.Member, out var inst))



To nie zadziała poprawnie, bo w MemberAccessNode:


Expr = "myEngine"
Member = "torque"



ma.Member to "torque", a nie "myEngine". Symbol table Instances jest indeksowana po nazwie instancji (myEngine), więc musisz zrobić:


if (AstVisitor.Instances.TryGetValue(ma.Expr, out var inst))
{
    var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
    Console.WriteLine("field type " + field.Type);

    if (field.Type == "f32")
        str += "%.2f";
    else
        str += "%d";
}





🔹 Kluczowe:
Instances → klucz = nazwa instancji (myEngine)

FieldValueNode → szukasz pola po f.Name == ma.Member (torque)

Teraz field.Type prawidłowo będzie "f32" i możesz dobrać format dla printf.




Chcesz, żebym pokazał pełny przykład generatora printf dla MemberAccessNode z dynamicznym formatem?

user
                if (secondArg is MemberAccessNode ma)
                {

                    if (AstVisitor.Instances.TryGetValue(((IdentifierExprNode)ma.Target).Name, out var inst))
                    {
                        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
                        Console.WriteLine("field type " + field.Type);

                        if (field.Type == "f32")
                        {

                            str += "%.2f";
                        }

                        else
                        {

                            str += "%d";
                        }
                    }
                    else
                    {

                        str += "%d";
                    }

                }

ChatGPT
Dokładnie tak, teraz jest poprawnie 🙂

Kilka uwag dla pewności:
ma.Target → to jest wyrażenie, które wskazuje instancję (myEngine).

Rzutujesz na IdentifierExprNode i bierzesz .Name → to będzie "myEngine".

Lookup w symbol table → Instances.TryGetValue(instanceName, out inst)

Teraz inst zawiera wszystkie FieldValueNode danej instancji.

Szukasz pola po nazwie → inst.Fields.FirstOrDefault(f => f.Name == ma.Member)

Teraz field.Type daje Ci "f32" albo "i32".

Domyślny format → jeśli instancja nie istnieje, możesz użyć %d lub %s, zależnie od potrzeb.


Przykład wygenerowanego C:


printf("engine torque: %.2f\n", myEngine.torque);





✅ Dzięki temu:
Zostawiasz w C referencję do pola (myEngine.torque).

Masz w generatorze typ pola (f32) i możesz dobrać format %.2f.




Jeżeli chcesz, mogę rozpisać pełny fragment funkcji generatora println, który obsługuje:
string literal + MemberAccess
różne typy (i32, f32)

pozostawia w C odwołania do pól struktury.

Chcesz, żebym to zrobił?

user
wlasnie ze nie printf("torque: \n", torque);

ChatGPT
Aaaa, teraz wszystko jasne 😎 — chcesz zostawić odwołanie do pola w strukturze, czyli np. myEngine.torque w kodzie C, ale formatować je odpowiednio w printf, bez używania literalnej wartości.

W takim przypadku generator robi dokładnie to, co pokazałeś, ale odwołanie w C powinno być do pola struktury, nie do samego identyfikatora:


printf("engine torque: %.2f\n", myEngine.torque);



A nie:


printf("engine torque: %.2f\n", torque); // ❌ torque samo w sobie nie istnieje w C





Kluczowe w generatorze:
ma.Target → nazwa instancji (myEngine)

ma.Member → nazwa pola (torque)

Instances[ma.Target.Name] → znajdziesz typ pola (f32/i32)

Wygenerowany kod:


str += $"{ma.Target.Name}.{ma.Member}";



I wtedy pełny printf wygląda tak:


printf("engine torque: %.2f\n", myEngine.torque);



✅ Masz zarówno typ pola do wyboru formatu, jak i referencję do pola w strukturze w C.

Chcesz, żebym pokazał pełny fragment generatora println, który działa dla literali i MemberAccess, z dobieraniem formatu %d/%.2f i odwołaniem do struktury?

user
%d nie dorzuca

ChatGPT
Aaa, już rozumiem Twój problem 🙂

Jeżeli w kodzie masz coś takiego:


if (field.Type == "f32")
    str += "%.2f";
else
    str += "%d";



i nie dorzuca %d, to najczęstsze przyczyny:
field jest null – FirstOrDefault(f => f.Name == ma.Member) nie znalazło pola → blok else nie wykonał się.

field.Type nie jest dokładnie "i32" – np. masz "int" albo "i32 " → warunek == "f32" i else działa inaczej.

str w ogóle nie jest appendowany do końcowego printf w generatorze.




Poprawiony fragment:


if (secondArg is MemberAccessNode ma)
{
    string fmt = "%d"; // domyślny format

    if (AstVisitor.Instances.TryGetValue(((IdentifierExprNode)ma.Target).Name, out var inst))
    {
        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
        if (field != null)
        {
            fmt = field.Type switch
            {
                "f32" => "%.2f",
                "i32" => "%d",
                _ => "%d"
            };
        }
    }

    str += fmt;
}



✅ Dzięki temu:
zawsze coś dorzuci do str (%.2f dla float, %d dla int, %d jako fallback).

nie trzeba polegać na else – format jest ustawiany najpierw na domyślny.




Jeżeli chcesz, mogę pokazać pełny generator printf dla MemberAccessNode i literalów, który zawsze dorzuca odpowiedni format i odwołanie do pola w strukturze.

Chcesz, żebym to zrobił?

user
 if (secondArg is MemberAccessNode ma)
                {

                    if (AstVisitor.Instances.TryGetValue(((IdentifierExprNode)ma.Target).Name, out var inst))
                    {
                        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
                        Console.WriteLine("field type " + field.Type);

                        if (field?.Type == "f32")
                        {

                            str += "%.2f";
                        }

                        else if(field?.Type == "i32")
                        {

                            str += "%d";
                        }
                    }

                        str += "%d";
               

ChatGPT
No i tu właśnie masz podwójny problem 🙂

Spójrz:


if (field?.Type == "f32")
{
    str += "%.2f";
}
else if (field?.Type == "i32")
{
    str += "%d";
}
}

str += "%d";   // <-- to zawsze się wykona, nawet jeśli już dodałeś format



Dlatego kończysz z dziwnymi efektami, bo %d leci niezależnie.



✅ Poprawna wersja

Zrób tak, żeby %d dodawało się tylko jako fallback:


if (secondArg is MemberAccessNode ma)
{
    string fmt = "%d"; // domyślny format

    if (AstVisitor.Instances.TryGetValue(((IdentifierExprNode)ma.Target).Name, out var inst))
    {
        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
        Console.WriteLine("field type " + field?.Type);

        if (field?.Type == "f32")
            fmt = "%.2f";
        else if (field?.Type == "i32")
            fmt = "%d";
    }

    str += fmt;
}





🔹 Efekt
Jeśli znajdzie torque: f32 → %.2f

Jeśli znajdzie horsepower: i32 → %d

Jeśli nic nie znajdzie albo typ nieznany → %d jako fallback




Chcesz, żebym od razu dorzucił przykład jak zbudować pełny printf("engine torque: %.2f\n", myEngine.torque); na podstawie tego kodu?

user
  if (secondArg is MemberAccessNode ma)
                {
                    string fmt = "%d";
                    if (AstVisitor.Instances.TryGetValue(((IdentifierExprNode)ma.Target).Name, out var inst))
                    {
                        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);
                        Console.WriteLine("field type " + field.Type);

                        if (field?.Type == "f32")
                        {

                            fmt = "%.2f";
                        }

                        else if(field?.Type == "i32")
                        {

                            fmt = "%d";
                        }
                    }

                        str += fmt;


                }

printf("torque: \n", torque);

dalej nie ma %d

ChatGPT
Dobra — już widać gdzie leży problem: %d nie pojawia się w rezultacie, bo prawdopodobnie doklejasz fmt poza ciągiem formatu (po zamknięciu cudzysłowu) albo w złym miejscu. Trzeba wbudować fmt wewnątrz łańcucha formatu przekazywanego do printf, a jako drugi argument podać referencję do pola (myEngine.torque).

Poniżej masz poprawioną, gotową do użycia wersję generatora println, która:
dobiera fmt na podstawie typu pola (f32 → %.2f, i32 → %d),

wstawia fmt do formatu (wewnątrz cudzysłowu),

jako drugi argument umieszcza referencję do pola instName.member.



public string GenPrintln(PrintlnNode node)
{
    var sb = new StringBuilder();

    // pierwszy argument - string literal, np. "\"torque: \""
    var firstArg = node.Args[0] as StringLiteralExpr;
    string text = firstArg?.Value ?? ""; // wartość z cudzysłowami
    // usuń zewnętrzne " i zabezpiecz znaki (proste)
    text = text.Trim('"').Replace("\\", "\\\\").Replace("\"", "\\\"");

    // drugi argument (może być MemberAccessNode)
    var secondArg = node.Args[1];

    string fmt = "%d"; // domyślny format
    string valueRef = "0"; // domyślny value fallback

    if (secondArg is MemberAccessNode ma)
    {
        // pobierz nazwę instancji i pole
        var instName = ((IdentifierExprNode)ma.Target).Name;
        var memberName = ma.Member;

        // lookup instancji w tabeli
        if (AstVisitor.Instances.TryGetValue(instName, out var inst))
        {
            var field = inst.Fields.FirstOrDefault(f => f.Name == memberName);
            if (field?.Type == "f32") fmt = "%.2f";
            else if (field?.Type == "i32") fmt = "%d";
            // inne typy -> dostosuj
        }

        // referencja do pola w C (zostawiamy odwołanie, nie literal)
        valueRef = $"{instName}.{memberName}";
    }
    else if (secondArg is IdentifierExprNode id)
    {
        // zwykły identyfikator
        valueRef = id.Name;
        // tutaj możesz próbować znaleźć typ po symbolach jeśli chcesz
    }
    else
    {
        // literal albo inne wyrażenie — wypisz bezpośrednio
        valueRef = secondArg.ToString();
    }

    // WAŻNE: fmt musi być wewnątrz format stringa
    sb.AppendLine($"printf(\"{text}{fmt}\\n\", {valueRef});");

    return sb.ToString();
}



Dlaczego wcześniej nie działało:
prawdopodobnie doklejałeś fmt poza granicami łańcucha formatowego (np. po ")), więc w wygenerowanym C string formatu był pusty: "torque: \n".

lub fmt był dopisywany do innego bufora niż ten, którego używałeś do wypisania printf.


Jak debugować szybko:
przed zwróceniem sb.ToString() zrób Console.WriteLine(sb.ToString()) i sprawdź, czy w wygenerowanym wierszu formatowym %d/%.2f są wewnątrz cudzysłowów.

upewnij się, że text nie zawiera już formatu (np. użytkownik nie podał "%.2f" samodzielnie) — w takim wypadku nie doklejaj fmt ponownie.


Jeżeli chcesz, mogę:
dorzucić obsługę vec3/string i innych typów,

albo przetestować przykładowy PrintlnNode i pokazać wynik generatora dla konkretnego AST (np. println("torque: ", myEngine.torque);).

user
else if(secondArg is IdentifierExprNode id){
                    string fmt = "%d";

                        if (id. .Type == "f32")
                        {

                            fmt = "%.2f";
                        }

                        else if(field?.Type == "i32")
                        {

                            fmt = "%d";
                        }
                }

ChatGPT
Widzę, co kombinujesz — próbujesz dobrać odpowiedni format do printf w zależności od typu zmiennej. Masz jednak parę rzeczy do poprawy:
Niepotrzebna kropka – w id. .Type masz literówkę, powinno być po prostu id.Type.

Spójność typów – skoro sprawdzasz id.Type == "f32" to przydałoby się trzymać konwencję i zawsze operować na typie zwracanym w AST (np. "i32", "f32", "bool").

Wystarczy jeden warunek – skoro sprawdzasz id.Type, to nie musisz jeszcze dodatkowo robić field?.Type. Chyba że chcesz porównywać oba i wybierać coś w rodzaju „najpewniejszego” typu.


Przykładowo możesz to uprościć:


else if (secondArg is IdentifierExprNode id)
{
    string fmt = "%d";

    switch (id.Type)
    {
        case "f32":
            fmt = "%.2f";
            break;
        case "i32":
            fmt = "%d";
            break;
        case "bool":
            fmt = "%d"; // albo "%s", zależy jak chcesz wypisywać
            break;
    }

    // np. zapisujesz ten format do dalszego użycia
}



Albo bardziej ogólnie (np. w jakimś helperze):


string GetPrintfFormat(string type) => type switch
{
    "f32" => "%.2f",
    "i32" => "%d",
    "bool" => "%d", // albo "%s"
    _     => "%s"
};



I potem tylko:


var fmt = GetPrintfFormat(id.Type);





Chcesz, żebym ci przygotował taki helper Type -> printf format jako osobną klasę/metodę (żeby nie musieć tego klepać w wielu miejscach)?

user
else if(secondArg is IdentifierExprNode id){
                    string fmt = "%d";

                        if (id?.Type == "f32")
                        {

                            fmt = "%.2f";
                        }

                        else if(id?.Type == "i32")
                        {

                            fmt = "%d";
                        }
                }

ChatGPT
To co masz teraz:


else if(secondArg is IdentifierExprNode id){
    string fmt = "%d";

    if (id?.Type == "f32")
    {
        fmt = "%.2f";
    }
    else if(id?.Type == "i32")
    {
        fmt = "%d";
    }
}



jest poprawne składniowo, ale:
id? nie ma sensu – skoro robisz pattern matching secondArg is IdentifierExprNode id, to id nigdy nie będzie null. Możesz spokojnie pisać id.Type.

Możesz to uprościć – lepiej użyć switch albo osobnej metody, wtedy nie będziesz powielał ifów w całym codegenie.


Na przykład:


else if (secondArg is IdentifierExprNode id)
{
    string fmt = id.Type switch
    {
        "f32" => "%.2f",
        "i32" => "%d",
        _     => "%s"
    };

    // tutaj masz już dobrany format
}



albo helper:


string GetPrintfFormat(string type) => type switch
{
    "f32" => "%.2f",
    "i32" => "%d",
    "bool" => "%d", // albo "%s"
    _     => "%s"
};



I potem:


else if (secondArg is IdentifierExprNode id)
{
    string fmt = GetPrintfFormat(id.Type);
}





Chcesz, żebym ci rozpisał pełną mapę formatów C dla typów RaceLang (np. f32, f64, i32, i64, bool, string), tak żebyś miał od razu gotowy helper?

user
ale torque nie ma typu w sensie IdExprNode nie ma typu

ChatGPT
Aaa, to teraz rozumiem problem 👍

Jeśli IdentifierExprNode (np. torque) nie ma własnego Type, to masz dwie opcje:



🔹 1. Dorzucić system typów do IdentifierExprNode

Najbardziej naturalne w kompilatorze — skoro torque to zmienna, to powinna gdzieś mieć przypisany typ.
Np. dodajesz pole:


class IdentifierExprNode : ExprNode
{
    public string Name { get; }
    public string? Type { get; set; } // <- uzupełniane podczas analizy semantycznej
}



Wtedy w momencie deklaracji zmiennej (let torque: f32 = ...;) wpisujesz id.Type = "f32".
I później w CodeGen masz wszystko pod ręką.



🔹 2. Typ wydobywasz z symbol table / Instances
Skoro trzymasz instancje w AstVisitor.Instances, to możesz z tego skorzystać również dla samych zmiennych.
Np. zamiast:


else if(secondArg is IdentifierExprNode id)
{
    string fmt = "%d";
    if (id?.Type == "f32") ...
}



robisz lookup:


else if (secondArg is IdentifierExprNode id)
{
    string fmt = "%d";

    if (AstVisitor.Instances.TryGetValue(id.Name, out var inst))
    {
        // np. zmienna lokalna albo globalna
        string type = inst.Type;
        fmt = type switch
        {
            "f32" => "%.2f",
            "i32" => "%d",
            _     => "%d"
        };
    }

    str += fmt;
}





👉 W praktyce: najlepiej dodać system typów (opcja 1), bo lookup w Instances zacznie być nieczytelny przy zmiennych lokalnych i parametrach funkcji.



Chcesz, żebym ci rozpisał krok po kroku, jak wprowadzić analizę typów do RaceLang (tak żeby każdy IdentifierExprNode znał swój typ po przejściu visitorów)?

user
mam varDecl.Type

ChatGPT
No to jesteś już o krok od rozwiązania 🚀

Jeżeli masz VarDeclNode.Type, to wystarczy powiązać IdentifierExprNode z tym VarDeclNode podczas analizy semantycznej.



🔹 Jak to spiąć
W VarDecl robisz rejestrację typu:



public override AstNode VisitVar_decl(RaceLangParser.Var_declContext ctx)
{
    var name = ctx.name_token().GetText();
    var type = ctx.type().GetText();

    var varDecl = new VarDeclNode
    {
        Name = name,
        Type = type,
        Value = Visit(ctx.expression()) as ExprNode
    };

    // Rejestracja zmiennej w tablicy symboli
    AstVisitor.SymbolTable[name] = varDecl;

    return varDecl;
}




W IdentifierExprNode ustawiasz Type na podstawie VarDecl:



public override AstNode VisitIdExpr(RaceLangParser.IdExprContext ctx)
{
    var name = ctx.GetText();

    var id = new IdentifierExprNode(name);

    // Szukamy deklaracji w symbolach
    if (AstVisitor.SymbolTable.TryGetValue(name, out var decl) && decl is VarDeclNode varDecl)
    {
        id.Type = varDecl.Type;
    }

    return id;
}




W CodeGen masz już typ dostępny:


else if (secondArg is IdentifierExprNode id)
{
    string fmt = id.Type switch
    {
        "f32" => "%.2f",
        "i32" => "%d",
        _     => "%d"
    };

    str += fmt;
}





🔹 Dlaczego tak lepiej niż kombinowanie z Instances?

Każda zmienna ma jedno źródło prawdy (VarDeclNode.Type).

IdentifierExprNode wie, jakiego jest typu, bez grzebania w AST później.

Rozszerzalne: później możesz dodać sprawdzanie typów, rzutowania, itd.



Chcesz, żebym rozpisał ci gotową minimalną implementację SymbolTable dla RaceLang (żeby IdentifierExprNode zawsze wiedział swój typ)?

user
 var idExpr = new IdentifierExprNode
            {
                Name = ctx.IDENTIFIER().GetText(),
                Type = ctx.
            };

ChatGPT
Dokładnie tutaj się zatrzymałeś 🙂 — parser (ctx) sam z siebie nie da ci typu, bo w gramatyce IDENTIFIER to tylko token. Typ bierzesz z deklaracji zmiennej, czyli z VarDeclNode.

Żeby to działało, musisz mieć prostą tablicę symboli (mapę: nazwa zmiennej → jej deklaracja).



🔹 Przykład SymbolTable


public static class SymbolTable
{
    public static Dictionary<string, VarDeclNode> Vars { get; } = new();
}





🔹 Rejestracja typu w VarDecl



public override AstNode VisitVar_decl(RaceLangParser.Var_declContext ctx)
{
    var name = ctx.name_token().GetText();
    var type = ctx.type().GetText();

    var varDecl = new VarDeclNode
    {
        Name = name,
        Type = type,
        Value = Visit(ctx.expression()) as ExprNode
    };

    // zapisz w symbolach
    SymbolTable.Vars[name] = varDecl;

    return varDecl;
}





🔹 Nadanie typu w IdentifierExprNode



public override AstNode VisitIdExpr(RaceLangParser.IdExprContext ctx)
{
    var name = ctx.IDENTIFIER().GetText();

    var idExpr = new IdentifierExprNode
    {
        Name = name
    };

    if (SymbolTable.Vars.TryGetValue(name, out var decl))
    {
        idExpr.Type = decl.Type; // przypisujemy typ z deklaracji
    }

    return idExpr;
}





🔹 Teraz masz dostęp do typu:


else if (secondArg is IdentifierExprNode id)
{
    string fmt = id.Type switch
    {
        "f32" => "%.2f",
        "i32" => "%d",
        _     => "%d"
    };

    str += fmt;
}





👉 Czy chcesz, żebym rozpisał ci to w pełnym mini-przykładzie (VarDecl + użycie zmiennej + printf w CodeGen), żebyś zobaczył jak torque przechodzi od deklaracji do printf?

user
a nie da sie inaczej

ChatGPT
Da się, ale wszystkie alternatywy sprowadzają się do tego samego: musisz skądś wziąć typ – a IdExprNode sam go nie ma.

Możesz to rozwiązać na kilka sposobów, bez budowania pełnej tabeli symboli:



1. Przechowywanie typu w FieldValueNode

Jeśli już przy parsowaniu inicjalizacji struktury wiesz, że torque jest f32, to możesz przepisać ten typ do FieldValueNode, np.:


var fieldValue = new FieldValueNode
{
    Name = ctx.name_token().GetText(),
    ValueNode = Visit(ctx.primary_expr()) as ExprNode,
    Type = correspondingFieldDecl.Type  // przepisz typ z deklaracji pola
};



Wtedy przy generowaniu printf możesz sięgnąć po fieldValue.Type.



2. Rozszerzenie IdentifierExprNode o pole ResolvedDecl

Zamiast wpisywać stringa Type, możesz węzłowi przypiąć link do deklaracji:


public class IdentifierExprNode : ExprNode
{
    public string Name { get; set; }
    public string Type => ResolvedDecl?.Type; // proxy
    public VarDeclNode ResolvedDecl { get; set; }
}



I w visitorze:


if (SymbolTable.Vars.TryGetValue(name, out var decl))
{
    idExpr.ResolvedDecl = decl;
}





3. Lookup tylko w momencie generowania kodu
Najprostsze, ale najmniej „czyste”:
w CodeGen sprawdzasz: jeśli masz IdentifierExprNode, to przed printf robisz wyszukiwanie w już znanych instancjach/strukturach:


if (secondArg is IdentifierExprNode id)
{
    string fmt = "%d";
    if (AstVisitor.VarDecls.TryGetValue(id.Name, out var decl))
    {
        if (decl.Type == "f32") fmt = "%.2f";
        else if (decl.Type == "i32") fmt = "%d";
    }
    str += fmt;
}



Czyli nie dopisujesz typu do AST, tylko odwołujesz się do VarDecl przy generacji.



🔑 Podsumowanie:
Bez typu w AST się nie obejdzie.
Możesz go przepisać od razu przy parsowaniu (wariant 1),
albo trzymać link do deklaracji (wariant 2 – czystszy),
albo robić lookup w CodeGen (wariant 3 – najszybszy hack).

👉 Chcesz żebym przygotował ci najprostszy wariant „hack” (lookup w CodeGen), czy idziemy w czystszą architekturę z ResolvedDecl?

user
no tak bo torque nie ma sam typu to co zrobic

ChatGPT
W punkt 👌 — torque nie ma sam w sobie typu, bo to jest pole w strukturze, a nie zmienna globalna. Typ istnieje tylko w deklaracji struktury Engine.

Żeby go poznać, masz dwie opcje:



🔹 1. Lookup po strukturze (najprostsze i wystarczy w twoim wypadku)
Masz już w AST instancję Engine myEngine = { … } → ta instancja wie, że jest typu Engine.
Więc kiedy widzisz myEngine.torque:


if (secondArg is MemberAccessNode ma)
{
    string fmt = "%d";

    // target to "myEngine"
    var targetName = ((IdentifierExprNode)ma.Target).Name;

    // znajdź instancję
    if (AstVisitor.Instances.TryGetValue(targetName, out var inst))
    {
        // szukasz deklaracji pola "torque"
        var field = inst.Fields.FirstOrDefault(f => f.Name == ma.Member);

        if (field?.Type == "f32") fmt = "%.2f";
        else if (field?.Type == "i32") fmt = "%d";
    }

    str += fmt;
}



➡️ Wtedy torque dziedziczy swój typ z deklaracji pola struktury.



🔹 2. Przepisanie typu do FieldValueNode przy parsowaniu

Kiedy tworzysz FieldValueNode podczas inicjalizacji:


var fieldValue = new FieldValueNode
{
    Name = ctx.name_token().GetText(),
    ValueNode = Visit(ctx.primary_expr()) as ExprNode,
    Type = structDecl.Fields.First(f => f.Name == ctx.name_token().GetText()).Type
};



➡️ Wtedy już na poziomie FieldValueNode masz typ i nie musisz szukać później.



🔹 3. Dodanie ResolvedDecl do IdentifierExprNode

Najczystsze rozwiązanie architektoniczne: IdentifierExprNode zamiast stringa trzyma wskaźnik na swoją deklarację (np. VarDeclNode albo FieldDeclNode). Dzięki temu zawsze wiesz, jaki ma typ.



👉 W twoim przypadku torque siedzi w struct Engine → czyli najlepsze rozwiązanie to lookup w instancji (wariant 1).

Chcesz, żebym rozpisał ci krok po kroku jak w VisitMemberAccess znaleźć ten field.Type dla torque, żeby printf miał już gotowy format?